from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.future import select
from typing import List, Optional
from datetime import datetime

from app.models.userModel import User
from app.schemas.userSchema import UserCreate
from sqlalchemy import func
from app.utils.security import get_password_hash


# 创建日志
async def create_user(db: AsyncSession, user: UserCreate):
    """创建新的日志记录

    Args:
        db: 异步数据库会话
        user: 包含日志数据的UserCreate对象

    Returns:
        新创建的User对象
    """
    hashed_password = get_password_hash(user.password)  # 哈希密码
    db_user = User(
        username=user.username,
        password=user.password,
        hashed_password=hashed_password  # 存储哈希后的密码
        # 其他字段...
    )
    #db_user = User(**user.model_dump())  # 将Schema转换为模型
    db.add(db_user)
    await db.commit()  # 提交事务
    await db.refresh(db_user)  # 刷新以获取数据库生成的字段（如ID和时间戳）
    return db_user

async def get_user_by_username(db: AsyncSession, username: str):
    result = await db.execute(select(User).where(User.username == username))
    return result.scalars().first()

# 获取单个日志
async def get_user(db: AsyncSession, user_id: int):
    """根据ID获取单个日志记录

    Args:
        db: 异步数据库会话
        user_id: 要查询的日志ID

    Returns:
        找到的User对象，如果不存在则返回None
    """
    result = await db.execute(select(User).filter(User.id == user_id))
    return result.scalars().first()

async def get_users_with_count(
        db: AsyncSession,
        skip: int = 0,
        limit: int = 100,
        action: Optional[str] = None,
        # 新增多条件参数

):
    """获取日志列表和总数量"""
    # 基础查询
    query = select(User)

    # 条件过滤
    if action:
        query = query.where(User.action == action)

    # 获取总数
    count_query = select(func.count()).select_from(query.subquery())
    total = (await db.execute(count_query)).scalar_one()

    # 获取分页数据
    items = (await db.execute(
        query.order_by(User.id.desc())  # 按时间倒序
        .offset(skip)
        .limit(limit)
    )).scalars().all()

    return {
        "total": total,
        "items": items,
        "skip": skip,
        "limit": limit
    }


# 获取日志列表（分页）
async def get_users(
        db: AsyncSession,
        skip: int = 0,
        limit: int = 100,
        action: Optional[str] = None  # 新增：按 action 过滤
):
    """获取日志列表（支持分页和条件查询）

    Args:
        db: 异步数据库会话
        skip: 跳过的记录数
        limit: 每页返回的最大记录数
        action: 按操作类型过滤（可选）
    """
    query = select(User)

    # 如果传入了 action，则添加过滤条件
    if action:
        query = query.where(User.action == action)

    # 分页
    query = query.offset(skip).limit(limit)

    result = await db.execute(query)
    return result.scalars().all()


# async def get_users(db: AsyncSession, skip: int = 0, limit: int = 100):
#     """获取日志列表，支持分页
#
#     Args:
#         db: 异步数据库会话
#         skip: 跳过的记录数（用于分页）
#         limit: 每页返回的最大记录数
#
#     Returns:
#         日志列表
#     """
#     result = await db.execute(select(User).offset(skip).limit(limit))
#     return result.scalars().all()


# 更新日志
async def update_user(db: AsyncSession, user_id: int, user: UserCreate):
    """更新日志记录

    Args:
        db: 异步数据库会话
        user_id: 要更新的日志ID
        user: 包含更新数据的UserCreate对象

    Returns:
        更新后的User对象，如果日志不存在则返回None
    """
    db_user = await get_user(db, user_id)
    if db_user:
        # 更新字段
        db_user.action = user.action
        db_user.details = user.details
        await db.commit()
        await db.refresh(db_user)
    return db_user


# 删除日志
async def delete_user(db: AsyncSession, user_id: int):
    """删除日志记录

    Args:
        db: 异步数据库会话
        user_id: 要删除的日志ID

    Returns:
        被删除的User对象，如果日志不存在则返回None
    """
    db_user = await get_user(db, user_id)
    if db_user:
        await db.delete(db_user)
        await db.commit()
    return db_user